home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / misc / xref_v1.1.lha / XRef / Tools / lib / scanpattern.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-29  |  7.0 KB  |  245 lines
  1. /*
  2. ** $PROJECT: xrefsupport.lib
  3. **
  4. ** $VER: scanpattern.c 1.2 (22.09.94) 
  5. **
  6. ** by
  7. **
  8. ** Stefan Ruppert , Windthorststraße 5 , 65439 Flörsheim , GERMANY
  9. **
  10. ** (C) Copyright 1994
  11. ** All Rights Reserved !
  12. **
  13. ** $HISTORY:
  14. **
  15. ** 22.09.94 : 001.002 :  SPM_DIR now gets the complete relative path
  16. ** 09.09.94 : 001.001 :  initial
  17. */
  18.  
  19. /* ------------------------------- includes ------------------------------- */
  20.  
  21. #include "/source/def.h"
  22.  
  23. #include "xrefsupport.h"
  24.  
  25. /* ------------------------------- defines -------------------------------- */
  26.  
  27. #define ANCHOR_BUFFER         512
  28. #define PATH_BUFFER           512
  29.  
  30. #define EOS                   '\0'
  31.  
  32. /* ------------------------------ structures ------------------------------ */
  33.  
  34. struct ScanDirData
  35. {
  36.    struct FileInfoBlock *sdd_Fib;
  37.    struct Hook *sdd_CallBack;
  38.    APTR sdd_UserData;
  39.    UBYTE sdd_Path[PATH_BUFFER];
  40.    UBYTE sdd_RealPath[PATH_BUFFER];
  41. };
  42.  
  43. /* --------------------------- local prototypes --------------------------- */
  44.  
  45. static LONG scan_dir(struct ScanDirData *dirdata);
  46.  
  47. /* ------------------------------ functions ------------------------------- */
  48.  
  49. LONG scan_patterns(STRPTR *patterns,struct Hook *callback,APTR userdata)
  50. {
  51.    LONG err = 0;
  52.    struct ScanDirData *dirdata = NULL;
  53.    struct AnchorPath *anchor;
  54.  
  55.    if((anchor = AllocMem(sizeof(*anchor)+ANCHOR_BUFFER, MEMF_ANY | MEMF_CLEAR)))
  56.    {
  57.       anchor->ap_Strlen    = ANCHOR_BUFFER;
  58.       anchor->ap_BreakBits = SIGBREAKF_CTRL_C;
  59.  
  60.       do
  61.       {
  62.          if((err = MatchFirst(*patterns, anchor)) == 0)
  63.          {
  64.             do
  65.             {
  66.                if(anchor->ap_Info.fib_DirEntryType > 0)
  67.                {
  68.                   if(!dirdata)
  69.                   {
  70.                      if((dirdata = AllocMem(sizeof(*dirdata),MEMF_ANY | MEMF_CLEAR)))
  71.                      {
  72.                         dirdata->sdd_Fib      = AllocDosObject(DOS_FIB,NULL);
  73.                         dirdata->sdd_CallBack = callback;
  74.                         dirdata->sdd_UserData = userdata;
  75.                      }
  76.                   }
  77.  
  78.                   if(dirdata && dirdata->sdd_Fib)
  79.                   {
  80.                      BPTR old;
  81.                      BPTR dir;
  82.  
  83.                      strcpy(dirdata->sdd_Path    ,"");
  84.                      strcpy(dirdata->sdd_RealPath,anchor->ap_Buf);
  85.  
  86.                      old = CurrentDir(anchor->ap_Current->an_Lock);
  87.                      if((dir = Lock(anchor->ap_Info.fib_FileName,SHARED_LOCK)))
  88.                      {
  89.                         CurrentDir(dir);
  90.                         if(!(err = CallHook(callback,(Object *) userdata,
  91.                                             SPM_DIR,
  92.                                             dirdata->sdd_Fib,
  93.                                             NULL,
  94.                                             dirdata->sdd_Path,
  95.                                             dirdata->sdd_RealPath)))
  96.                         {
  97.                            err = scan_dir(dirdata);
  98.                         }
  99.                      }
  100.                      CurrentDir(old);
  101.                      UnLock(dir);
  102.                   } else
  103.                      err = ERROR_NO_FREE_STORE;
  104.                } else if(anchor->ap_Info.fib_DirEntryType < 0)
  105.                {
  106.                   BPTR fh;
  107.                   BPTR olddir;
  108.  
  109.                   olddir = CurrentDir(anchor->ap_Current->an_Lock);
  110.                   if((fh = Open(anchor->ap_Info.fib_FileName,MODE_OLDFILE)))
  111.                   {
  112.                      err = CallHook(callback,(Object *) userdata,
  113.                                     SPM_FILE,
  114.                                     &anchor->ap_Info,
  115.                                     fh,
  116.                                     anchor->ap_Info.fib_FileName,
  117.                                     anchor->ap_Buf);
  118.                      Close(fh);
  119.                   }
  120.                   CurrentDir(olddir);
  121.                }
  122.  
  123.             } while(err == 0 && (err = MatchNext(anchor)) == 0);
  124.          }
  125.  
  126.          if(err == ERROR_NO_MORE_ENTRIES)
  127.          {
  128.             SetIoErr(0);
  129.             err = 0;
  130.          }
  131.  
  132.          patterns++;
  133.       } while(*patterns && err == 0);
  134.  
  135.       if(dirdata)
  136.       {
  137.          if(dirdata->sdd_Fib)
  138.             FreeDosObject(DOS_FIB,dirdata->sdd_Fib);
  139.  
  140.          FreeMem(dirdata,sizeof(*dirdata));
  141.       }
  142.  
  143.       FreeMem(anchor,sizeof(*anchor)+ANCHOR_BUFFER);
  144.    }
  145.  
  146.    return(err);
  147. }
  148.  
  149. static LONG scan_dir(struct ScanDirData *dirdata)
  150. {
  151.    LONG retval = 0;
  152.    BPTR dir;
  153.  
  154.    if(dir = Lock(dirdata->sdd_Path,SHARED_LOCK))
  155.    {
  156.       if(Examine(dir,dirdata->sdd_Fib))
  157.       {
  158.          while(ExNext(dir,dirdata->sdd_Fib) && retval == 0)
  159.          {
  160.             if(SetSignal(0,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
  161.             {
  162.                SetIoErr(ERROR_BREAK);
  163.                break;
  164.             }
  165.  
  166.             if(AddPart(dirdata->sdd_Path,dirdata->sdd_Fib->fib_FileName,PATH_BUFFER))
  167.             {
  168.                if(AddPart(dirdata->sdd_RealPath,dirdata->sdd_Fib->fib_FileName,PATH_BUFFER))
  169.                {
  170.                   if(dirdata->sdd_Fib->fib_DirEntryType > 0)
  171.                   {
  172.                      if(!(retval = CallHook(dirdata->sdd_CallBack,(Object *) dirdata->sdd_UserData,
  173.                                             SPM_DIR,
  174.                                             dirdata->sdd_Fib,
  175.                                             NULL,
  176.                                             dirdata->sdd_Path,
  177.                                             dirdata->sdd_RealPath)))
  178.                         retval = scan_dir(dirdata);
  179.                   }
  180.                   else
  181.                   {
  182.                      BPTR fh;
  183.  
  184.                      if((fh = Open(dirdata->sdd_Path,MODE_OLDFILE)))
  185.                      {
  186.                         retval = CallHook(dirdata->sdd_CallBack,(Object *) dirdata->sdd_UserData,
  187.                                           SPM_FILE,
  188.                                           dirdata->sdd_Fib,
  189.                                           fh,
  190.                                           dirdata->sdd_Path,
  191.                                           dirdata->sdd_RealPath);
  192.                         Close(fh);
  193.                      }
  194.                   }
  195.  
  196.                   *PathPart(dirdata->sdd_RealPath) = EOS;
  197.                }
  198.                *PathPart(dirdata->sdd_Path) = EOS;
  199.             }
  200.          }
  201.  
  202.          if(retval == 0)
  203.             if((retval = IoErr()) == ERROR_NO_MORE_ENTRIES)
  204.             {
  205.                retval = 0;
  206.                SetIoErr(0);
  207.             }
  208.  
  209.       }
  210.       UnLock(dir);
  211.    }
  212.  
  213.    return(retval);
  214. }
  215.  
  216. static RegCall LONG stathook(REGA0 struct Hook *hook,REGA2 struct ScanStat *stat,REGA1 struct spMsg *msg)
  217. {
  218.    switch(msg->Msg)
  219.    {
  220.    case SPM_DIR:
  221.       stat->ss_Directories++;
  222.       break;
  223.    case SPM_FILE:
  224.       stat->ss_Files++;
  225.       stat->ss_TotalFileSize += msg->Fib->fib_Size;
  226.       break;
  227.    }
  228.  
  229.    return(0);
  230. }
  231.  
  232. void getscanstat(STRPTR *patterns,struct ScanStat *stat)
  233. {
  234.    struct Hook scanstat = {NULL};
  235.  
  236.    scanstat.h_Entry = (HOOKFUNC) stathook;
  237.  
  238.    stat->ss_Directories   = 0;
  239.    stat->ss_Files         = 0;
  240.    stat->ss_TotalFileSize = 0;
  241.  
  242.    scan_patterns(patterns,&scanstat,stat);
  243. }
  244.  
  245.